package 贪心;
import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.stream.IntStream;
public class leetcode937重新排列日志 {
	/**
	 * 这个 排序 规则 有点 让我 
	 * 琢磨 不 透 了 已经
	 * Integer [] arr = {2,0,1,3,3,6,8};
	 * 对于 直接  return 1;   排序 后    如下
	 * {2,0,1,3,3,6,8};
	 * 直接 return  0  也是 
	 * {2,0,1,3,3,6,8};
	 * 这个 结果
	 * 直接 return  -1 ; 结果如下 :
	 * [8, 6, 3, 3, 1, 0, 2]
	 * 并没有  排好顺序  只是 简单的 倒序 了 而已
	 * 
	 * 看完 下面之后的 代码 有没有 更深刻的 
	 * 认识
	 * 			if(o1 > o2)
					return 1;
				else if( o1 == o2)
					return 0;
				else
					return -1;
			}
			上面的代码
			等价  于
			return o1  -  o2;
		
		如果 直接 返回 一个 return 1;
		一个 常数的 话  表示 所有的 情况   都返回 一个 常数 
		那么 这个 排序的 结果 就可想 而知 了
	 */
	
	public static void main(String []args) {
		Integer [] arr = {2,0,1,3,3,6,8};
//		Collections.sort();
//		Arrays.sort(arr,new Comparator<Integer>() {
//
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				// TODO Auto-generated method stub
//				return  -1;
//			}
//			
//		});
		Arrays.sort(arr,new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				if(o1 > o2)
					return 1;
				else if( o1 == o2)
					return 0;
				else
					return -1;
			}
			
		});
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 这道题 还是 能明白 好多 东西 的 
	 * 至少 排序的 规则 很清楚
	 * 
	 */
	/**
	 * 语法的 意外 收获 
	 * Comparator<String>  com = new  MyComparator();
	 * 上面的 是 正确的写法       下面的是 报错的 写法
	 * Comparator<String>  com = new  MyComparator<>();
	 * 首先 注意 这一点 你自己的 MyComparator类        class    是 没有 声明 泛型的  的
	 * 那你 写 这个   <>  泛型 占位符的 意义何在
	 * 正确的 写法 右边 写法  泛型 那是 因为 该接口 本身 就  声明的 是一个 泛型 接口  
	 */
	
	static String [] solution(String s[]) {
		 Comparator<String>  com = new  MyComparator(); 
//		 MyComparator  com1 = new  MyComparator(); 
		 Arrays.sort(s,com);
		 return s;
	}
	static class MyComparator implements Comparator<String> {

		@Override
		public int compare(String o1, String o2) {
				char c1 = o1.charAt(o1.length() - 1);
				char c2 = o2.charAt(o2.length() - 1);
				boolean d = '0' <= c1 && c1 <= '9' ;
				boolean l = 'a' <= c2 && c2 <= 'z' ; 
			if(  d && l) {
				return  1 ;
			}
			//  说明  是同类型的  要么 全是 digit 或者 要么 全是 letters 跟着模拟就行了
			else if(  !d && l) {
				 int index1 = o1.indexOf(' ') + 1;
				 int index2 = o2.indexOf(' ') + 1;
				 String s1 = o1.substring(index1);
				 String s2 = o2.substring(index2);
//				 if(o1.substring(index1).equals(o2.substring(index2)))
//				      return o1.substring(0,index1).compareTo(o2.substring(0,index2));    	
				 if(s1.equals(s2))
					 return o1.substring(0,index1).compareTo(o2.substring(0,index2));
//					 return s1.compareTo(s2);
				 else
					 return s1.compareTo(s2);
					 
			}
			else if( !l && d)
				return 0;
			else 
				return -1;
		}
		
	}
}
class S0{
    public String[] reorderLogFiles(String[] logs) {
        return IntStream.range(0, logs.length).mapToObj(i -> new Log(logs[i], i)).sorted().map(e -> e.raw).toArray(String[]::new);
    }

    //保存排序需要的必要信息
    class Log implements Comparable<Log> {
        String head;
        String body;
        String raw;
        int index;
        int type;

        public Log(String raw, int index) {
            this.raw = raw;
            this.index = index;
            int i = raw.indexOf(" ");
            head = raw.substring(0, i);
            body = raw.substring(i + 1);
            //数字1 字母0
            type = Character.isDigit(body.charAt(0)) ? 1 : 0;
        }

        //{(x, y) such that x.compareTo(y) <= 0}.
        @Override
        public int compareTo(Log o) {
            if (this.type != o.type) return this.type - o.type;//head为字母的放在数字前
            if (this.type == 1) return this.index - o.index;//head为数字的按照下标排序
            return !this.body.equals(o.body) ? this.body.compareTo(o.body) : this.head.compareTo(o.head); //head为字母先按body再按head
        }
    }
}
/**
class S1 {
    class Log {
        int type, idx;
        String ori, sign, content;
        Log(String s, int _idx) {
            idx = _idx;
            int n = s.length(), i = 0;
            while (i < n && s.charAt(i) != ' ') i++;
            sign = s.substring(0, i);
            content = s.substring(i + 1);
            ori = s;
            type = Character.isDigit(content.charAt(0)) ? 1 : 0;
        }
    }
    public String[] reorderLogFiles(String[] logs) {
        int n = logs.length;
        List<Log> list = new ArrayList<>();
        for (int i = 0; i < n; i++) list.add(new Log(logs[i], i));
        Collections.sort(list, (a, b)->{
            if (a.type != b.type) return a.type - b.type;
            if (a.type == 1) return a.idx - b.idx;
            return !a.content.equals(b.content) ? a.content.compareTo(b.content) : a.sign.compareTo(b.sign);
        });
        String[] ans = new String[n];
        for (int i = 0; i < n; i++) ans[i] = list.get(i).ori;
        return ans;
    }
}
*/